WebSocket একটি প্রোটোকল যা ব্রাউজার এবং সার্ভারের মধ্যে দ্বিমুখী যোগাযোগ (bidirectional communication) সাপোর্ট করে। Spring Boot-এ WebSocket ক্লায়েন্ট ইন্টিগ্রেট করে আমরা রিয়েল-টাইম ডেটা আদান-প্রদান করতে পারি। এটি চ্যাট অ্যাপ্লিকেশন, লাইভ আপডেট, স্টক মার্কেট ট্র্যাকিং, গেমিং, ইত্যাদি অ্যাপ্লিকেশনে ব্যবহৃত হতে পারে।

Spring Boot-এ WebSocket ক্লায়েন্ট ইন্টিগ্রেট করতে আমরা spring-websocket লাইব্রেরি এবং Stomp প্রোটোকল ব্যবহার করতে পারি। এখানে WebSocket ক্লায়েন্ট কনফিগারেশন এবং উদাহরণ দেয়া হচ্ছে।

Spring Boot WebSocket Client Integration এর জন্য ধাপসমূহ

1. প্রয়োজনীয় ডিপেন্ডেন্সি যুক্ত করা

Spring Boot অ্যাপ্লিকেশনে WebSocket এবং STOMP (Simple Text Oriented Messaging Protocol) এর জন্য নিচের ডিপেন্ডেন্সি গুলি ব্যবহার করা হবে:

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-websocket</artifactId>
</dependency>
<dependency>
    <groupId>org.springframework.messaging</groupId>
    <artifactId>spring-messaging</artifactId>
</dependency>
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-stomp</artifactId>
</dependency>

2. WebSocket Client কনফিগারেশন (WebSocketStompClient)

WebSocket ক্লায়েন্টের মাধ্যমে সার্ভারের সাথে WebSocket সংযোগ স্থাপন করা হয়। WebSocketStompClient এবং StompSession ব্যবহার করা হয় WebSocket স্ট্রিমিং ডেটার জন্য।

WebSocketClientConfig.java

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.messaging.Message;
import org.springframework.messaging.simp.stomp.StompSession;
import org.springframework.messaging.simp.stomp.StompSessionHandlerAdapter;
import org.springframework.web.socket.client.WebSocketClient;
import org.springframework.web.socket.client.standard.StandardWebSocketClient;
import org.springframework.web.socket.WebSocketStompClient;

@Configuration
public class WebSocketConfig {

    @Bean
    public WebSocketStompClient stompClient() {
        WebSocketClient client = new StandardWebSocketClient();
        WebSocketStompClient stompClient = new WebSocketStompClient(client);
        stompClient.setMessageConverter(new org.springframework.messaging.simp.stomp.StompMessageConverter());
        return stompClient;
    }

    @Bean
    public StompSessionHandlerAdapter stompSessionHandler() {
        return new StompSessionHandlerAdapter() {
            @Override
            public void handleFrame(Message<?> message) {
                // Handle the message you receive from the server
                System.out.println("Received message: " + message);
            }
        };
    }
}

3. WebSocket Client Connect এবং Send/Receive Data

WebSocket ক্লায়েন্ট সার্ভারের সাথে সংযুক্ত হওয়ার পর STOMP প্রোটোকলের মাধ্যমে message send এবং receive করা যায়।

WebSocketClientService.java

import org.springframework.messaging.simp.stomp.StompSession;
import org.springframework.messaging.simp.stomp.StompSessionHandlerAdapter;
import org.springframework.stereotype.Service;

@Service
public class WebSocketClientService {

    private final WebSocketStompClient stompClient;
    private final StompSessionHandlerAdapter stompSessionHandler;

    public WebSocketClientService(WebSocketStompClient stompClient, StompSessionHandlerAdapter stompSessionHandler) {
        this.stompClient = stompClient;
        this.stompSessionHandler = stompSessionHandler;
    }

    public void connect() {
        String wsUrl = "ws://localhost:8080/ws-endpoint"; // Replace with your WebSocket server URL
        try {
            StompSession session = stompClient.connect(wsUrl, stompSessionHandler).get();  // Blocking call
            session.send("/app/chat", "Hello from WebSocket Client");  // Sending message
            System.out.println("Message sent to server");
        } catch (Exception e) {
            System.out.println("Error in connecting: " + e.getMessage());
        }
    }
}

4. WebSocket Server Configuration (Server-Side)

এখন, WebSocket ক্লায়েন্টের সাথে যোগাযোগ করতে একটি WebSocket সার্ভার কনফিগার করতে হবে। এখানে STOMP প্রোটোকলের মাধ্যমে ক্লায়েন্টের সাথে যোগাযোগ করা হবে।

WebSocketServerConfig.java (Server-side)

import org.springframework.context.annotation.Configuration;
import org.springframework.messaging.simp.SimpMessagingTemplate;
import org.springframework.messaging.simp.annotation.SubscribeMapping;
import org.springframework.web.socket.config.annotation.EnableWebSocketMessageBroker;
import org.springframework.web.socket.config.annotation.WebSocketMessageBrokerConfigurer;
import org.springframework.web.socket.config.annotation.StompEndpointRegistry;

@Configuration
@EnableWebSocketMessageBroker
public class WebSocketServerConfig implements WebSocketMessageBrokerConfigurer {

    @Override
    public void registerStompEndpoints(StompEndpointRegistry registry) {
        registry.addEndpoint("/ws-endpoint").setAllowedOrigins("*").withSockJS();  // Endpoint for WebSocket
    }

    @Override
    public void configureMessageBroker(org.springframework.messaging.simp.config.MessageBrokerRegistry config) {
        config.enableSimpleBroker("/topic", "/queue");
        config.setApplicationDestinationPrefixes("/app");
    }

    @SubscribeMapping("/chat")
    public String handleChatMessage(String message) {
        return "Server received: " + message;
    }
}

5. Application Runner to Start the WebSocket Client

এখন, একটি ApplicationRunner ব্যবহার করে WebSocket ক্লায়েন্ট অ্যাপ্লিকেশন শুরু করা হবে।

WebSocketClientApp.java

import org.springframework.boot.CommandLineRunner;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.ApplicationContext;

@SpringBootApplication
public class WebSocketClientApp implements CommandLineRunner {

    private final WebSocketClientService webSocketClientService;

    public WebSocketClientApp(WebSocketClientService webSocketClientService) {
        this.webSocketClientService = webSocketClientService;
    }

    public static void main(String[] args) {
        SpringApplication.run(WebSocketClientApp.class, args);
    }

    @Override
    public void run(String... args) {
        // Connecting the WebSocket client to the server
        webSocketClientService.connect();
    }
}

6. WebSocket Server (Testing the Client)

WebSocket ক্লায়েন্ট সফলভাবে সংযুক্ত হলে এটি /app/chat এ মেসেজ পাঠাবে। সার্ভার সেটআপে এই মেসেজ গ্রহণ এবং রেসপন্স প্রদান করা হবে।

Server Response (on receiving message)

যখন ক্লায়েন্ট একটি মেসেজ পাঠাবে, সার্ভার সেই মেসেজ গ্রহণ করে রেসপন্স পাঠাবে। ক্লায়েন্ট সেই রেসপন্সটি গ্রহণ করবে।

উপসংহার

এই উদাহরণে, আমরা দেখিয়েছি কিভাবে Spring Boot এবং WebSocket ক্লায়েন্ট ইন্টিগ্রেট করা যায়। WebSocket সার্ভারের সাথে WebSocketClient ব্যবহার করে রিয়েল-টাইম মেসেজিং এবং ডেটা আদান-প্রদান সহজেই করা যায়। STOMP প্রোটোকলের মাধ্যমে মেসেজিং পরিচালনা এবং Spring Messaging এর সাহায্যে দুইটি পক্ষের মধ্যে রিয়েল-টাইম যোগাযোগ সিস্টেম তৈরি করা যায়।

এই পদ্ধতি WebSocket ক্লায়েন্ট তৈরি এবং Spring Boot এর সাথে ইন্টিগ্রেট করার প্রাথমিক ধারণা দেয়, যেটি আপনি আরও কাস্টমাইজ এবং উন্নত করতে পারেন।

WebSocket হলো একটি প্রোটোকল যা দুইটি সিস্টেম (যেমন ক্লায়েন্ট এবং সার্ভার) এর মধ্যে স্থায়ী, ডুয়াল-ডিরেকশনাল এবং কমিউনিকেশন লিঙ্ক তৈরি করতে ব্যবহৃত হয়। এটি HTTP প্রোটোকল থেকে আলাদা, যেখানে একবার একটি কানেকশন তৈরি হলে, ক্লায়েন্ট এবং সার্ভার উভয়ই একে অপরকে বার্তা পাঠাতে পারে, এবং এটি একটি ওপেন কানেকশন ব্যবহারের মাধ্যমে কমিউনিকেশন করতে সক্ষম।

WebSocket-এর বৈশিষ্ট্য:

1. ডুয়াল-ডিরেকশনাল যোগাযোগ: ক্লায়েন্ট এবং সার্ভার উভয় পক্ষই একে অপরকে বার্তা পাঠাতে পারে, যা HTTP প্রোটোকলের তুলনায় বেশি ইন্টারঅ্যাকটিভ।
2. কম লেটেন্সি: একবার কানেকশন স্থাপন হলে, বার্তা প্রেরণ এবং গ্রহণ দ্রুত হয়।
3. স্টেটফুল কানেকশন: একটি WebSocket কানেকশন স্থায়ী থাকে যতক্ষণ না এটি বন্ধ করা হয়।
4. পাশাপাশি একাধিক ক্লায়েন্টের সাথে যোগাযোগ: এটি সহজেই মুলতুবি থাকতে পারে এবং একাধিক ক্লায়েন্টের সঙ্গে যোগাযোগ করতে পারে।

Spring Boot-এ WebSocket ব্যবহার

Spring Boot ব্যবহার করে WebSocket এর সুবিধা নেওয়া যায় অনেক সহজে। Spring WebSocket API দিয়ে আমরা একটি ওয়েবসাইটে রিয়েলটাইম যোগাযোগ সিস্টেম তৈরি করতে পারি, যেমন চ্যাট অ্যাপ্লিকেশন বা লাইভ নোটিফিকেশন সিস্টেম।

Spring Boot-এ WebSocket ব্যবহারের জন্য সাধারণত দুটি প্রধান ধাপ রয়েছে:

1. WebSocket সাপোর্ট সক্ষম করা
2. WebSocket সার্ভার এবং ক্লায়েন্ট তৈরি করা

1. WebSocket সাপোর্ট সক্ষম করা (Spring Boot Configuration)

প্রথমে Spring Boot অ্যাপ্লিকেশনটির pom.xml-এ প্রয়োজনীয় ডিপেনডেন্সি যোগ করতে হবে।

Maven:

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-websocket</artifactId>
</dependency>

Gradle:

implementation 'org.springframework.boot:spring-boot-starter-websocket'

2. WebSocket Configuration

Spring Boot অ্যাপ্লিকেশন কনফিগার করার জন্য একটি কনফিগারেশন ক্লাস তৈরি করতে হবে, যেখানে WebSocket এন্ডপয়েন্ট সেট করা হবে।

import org.springframework.context.annotation.Configuration;
import org.springframework.messaging.simp.config.MessageBrokerRegistry;
import org.springframework.web.socket.config.annotation.EnableWebSocket;
import org.springframework.web.socket.config.annotation.StompEndpointRegistry;
import org.springframework.web.socket.config.annotation.WebSocketMessageBrokerConfigurer;
import org.springframework.web.socket.config.annotation.WebSocketConfigurer;

@Configuration
@EnableWebSocket
public class WebSocketConfig implements WebSocketMessageBrokerConfigurer {

    @Override
    public void registerStompEndpoints(StompEndpointRegistry registry) {
        registry.addEndpoint("/ws").withSockJS();  // WebSocket endpoint
    }

    @Override
    public void configureMessageBroker(MessageBrokerRegistry registry) {
        registry.enableSimpleBroker("/topic");  // Enable message broker for /topic endpoint
        registry.setApplicationDestinationPrefixes("/app");  // Prefix for app messages
    }
}

ব্যাখ্যা:

• @EnableWebSocket: Spring WebSocket সাপোর্ট সক্ষম করে।
• registerStompEndpoints: WebSocket এন্ডপয়েন্ট /ws দিয়ে স্টার্ট হবে, যেখানে withSockJS() ব্যবহার করা হয়েছে ফলব্যাক সাপোর্টের জন্য।
• configureMessageBroker: /topic নামে একটি সিম্পল মেসেজ ব্রোকার সেট করা হয়েছে এবং /app নামের অ্যাপ্লিকেশন ডেস্টিনেশন পাথটি নির্ধারণ করা হয়েছে।

3. WebSocket Controller

Spring WebSocket Controller ব্যবহার করে মেসেজ প্রেরণ এবং গ্রহণ করা হয়। এই কন্ট্রোলারটি সার্ভারের মাধ্যমে ক্লায়েন্টের সাথে রিয়েলটাইম কমিউনিকেশন নিশ্চিত করবে।

import org.springframework.messaging.handler.annotation.MessageMapping;
import org.springframework.messaging.simp.SimpMessagingTemplate;
import org.springframework.stereotype.Controller;

@Controller
public class WebSocketController {

    private final SimpMessagingTemplate messagingTemplate;

    public WebSocketController(SimpMessagingTemplate messagingTemplate) {
        this.messagingTemplate = messagingTemplate;
    }

    // Listen for messages sent to /app/chat
    @MessageMapping("/chat")
    public void sendMessage(String message) {
        messagingTemplate.convertAndSend("/topic/messages", message);  // Send message to /topic/messages
    }
}

ব্যাখ্যা:

• @MessageMapping("/chat"): /app/chat এ পাঠানো বার্তাগুলি গ্রহণ করবে।
• SimpMessagingTemplate: মেসেজগুলোকে /topic/messages পাথের মাধ্যমে ক্লায়েন্টদের পাঠাবে।

4. WebSocket Client (HTML + JavaScript)

ক্লায়েন্ট সাইডে, WebSocket কানেকশন এবং মেসেজ পাঠানোর জন্য JavaScript ব্যবহার করতে হবে।

<!DOCTYPE html>
<html>
<head>
    <title>WebSocket Chat</title>
    <script src="https://cdnjs.cloudflare.com/ajax/libs/sockjs-client/1.5.1/sockjs.min.js"></script>
    <script src="https://cdnjs.cloudflare.com/ajax/libs/stomp.js/2.3.3/stomp.min.js"></script>
</head>
<body>
    <h1>WebSocket Chat</h1>
    <div id="chat"></div>
    <input type="text" id="message" placeholder="Type a message" />
    <button onclick="sendMessage()">Send</button>

    <script>
        const socket = new SockJS('/ws');
        const stompClient = Stomp.over(socket);

        stompClient.connect({}, function(frame) {
            console.log('Connected: ' + frame);
            stompClient.subscribe('/topic/messages', function(response) {
                document.getElementById("chat").innerHTML += "<p>" + response.body + "</p>";
            });
        });

        function sendMessage() {
            const message = document.getElementById("message").value;
            stompClient.send("/app/chat", {}, message);
            document.getElementById("message").value = '';
        }
    </script>
</body>
</html>

ব্যাখ্যা:

• SockJS এবং STOMP.js: ক্লায়েন্ট সাইডে WebSocket কানেকশন স্থাপন এবং মেসেজ পাঠানোর জন্য ব্যবহৃত হয়।
• stompClient.subscribe("/topic/messages", ...): ক্লায়েন্টটি /topic/messages থেকে মেসেজ গ্রহণ করে এবং পৃষ্ঠাতে দেখায়।
• stompClient.send("/app/chat", ...): ক্লায়েন্ট মেসেজ পাঠানোর জন্য /app/chat এন্ডপয়েন্টে একটি মেসেজ পাঠায়।

5. Spring Boot অ্যাপ্লিকেশন রান করা

এখন Spring Boot অ্যাপ্লিকেশনটি রান করলে /ws WebSocket এন্ডপয়েন্টটি সক্রিয় হবে। ক্লায়েন্ট ব্রাউজারে HTML ফাইলটি খুললে, আপনি real-time chat করতে পারবেন।

উপসংহার

WebSocket একটি শক্তিশালী প্রযুক্তি, যা রিয়েল-টাইম ডেটা ট্রান্সফারের জন্য আদর্শ। Spring Boot WebSocket ইন্টিগ্রেশন খুবই সহজ এবং প্রভাবশালী, এবং এটি দ্রুত রিয়েল-টাইম অ্যাপ্লিকেশন যেমন চ্যাট অ্যাপ, নোটিফিকেশন সিস্টেম, বা লাইভ ডেটা ফিড তৈরি করতে সাহায্য করে। Spring Boot-এ WebSocket সেটআপ করা সহজ এবং এটি মেসেজ ব্রোকার এবং STOMP প্রোটোকল ব্যবহার করে কার্যকরভাবে রিয়েল-টাইম কমিউনিকেশন সমর্থন করে।

WebSocket একটি পূর্ণ-ডুপ্লেক্স (Full-Duplex) যোগাযোগ প্রোটোকল যা ক্লায়েন্ট এবং সার্ভারের মধ্যে দীর্ঘস্থায়ী সংযোগ স্থাপন করে। এটি একটি হালকা, দ্রুত এবং স্থিতিশীল প্রোটোকল যা real-time অ্যাপ্লিকেশন যেমন চ্যাট অ্যাপ্লিকেশন, লাইভ ডেটা ফিড, এবং গেমিং সার্ভিসের জন্য উপযুক্ত।

Spring Boot ব্যবহার করে WebSocket ক্লায়েন্ট তৈরি করা বেশ সহজ, এবং এতে Spring WebSocket স্টার্টার ডিপেনডেন্সি ব্যবহার করা হয়।

Spring Boot WebSocket Client তৈরি করার ধাপগুলো

১. Spring Boot WebSocket ক্লায়েন্টের জন্য ডিপেনডেন্সি যোগ করা

প্রথমে আপনার pom.xml বা build.gradle ফাইলে WebSocket ডিপেনডেন্সি যোগ করতে হবে।

Maven:

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-websocket</artifactId>
</dependency>

Gradle:

implementation 'org.springframework.boot:spring-boot-starter-websocket'

২. WebSocket Client তৈরি করা

Spring Boot এ WebSocket ক্লায়েন্ট তৈরি করার জন্য WebSocketStompClient ব্যবহার করা হয়। এটি একটি স্টম্প (STOMP) প্রোটোকল ব্যবহার করে সার্ভারের সাথে সংযোগ স্থাপন করতে সহায়ক।

WebSocketClient এর জন্য কনফিগারেশন:

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.web.socket.client.WebSocketClient;
import org.springframework.web.socket.client.standard.StandardWebSocketClient;
import org.springframework.web.socket.WebSocketHandler;

@Configuration
public class WebSocketConfig {

    @Bean
    public WebSocketClient webSocketClient() {
        return new StandardWebSocketClient();
    }

    @Bean
    public WebSocketHandler webSocketHandler() {
        return new MyWebSocketHandler();
    }
}

WebSocketHandler তৈরি করা:

WebSocketHandler একটি কাস্টম ক্লাস হতে পারে যা WebSocket মেসেজ প্রক্রেসিং এবং ইভেন্ট হ্যান্ডলিং করে।

import org.springframework.web.socket.WebSocketMessage;
import org.springframework.web.socket.handler.TextWebSocketHandler;
import org.springframework.web.socket.TextMessage;
import org.springframework.web.socket.WebSocketSession;

public class MyWebSocketHandler extends TextWebSocketHandler {
    @Override
    public void handleTextMessage(WebSocketSession session, TextMessage message) throws Exception {
        // মেসেজ রিসিভ করা
        System.out.println("Received message: " + message.getPayload());
        // মেসেজ পাঠানো
        session.sendMessage(new TextMessage("Hello from WebSocket Client"));
    }
}

৩. WebSocketClient শুরু করা এবং সার্ভারের সাথে সংযোগ স্থাপন

এখন, আপনি WebSocketClient ব্যবহার করে WebSocket সার্ভারে সংযোগ স্থাপন করবেন।

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.web.socket.client.WebSocketClient;
import org.springframework.web.socket.WebSocketSession;
import org.springframework.web.socket.TextMessage;

@Service
public class WebSocketClientService {

    private final WebSocketClient webSocketClient;

    @Autowired
    public WebSocketClientService(WebSocketClient webSocketClient) {
        this.webSocketClient = webSocketClient;
    }

    public void connectToWebSocketServer(String uri) throws Exception {
        WebSocketSession session = webSocketClient.doHandshake(new MyWebSocketHandler(), uri).get();
        System.out.println("Connected to WebSocket server");

        // মেসেজ পাঠানো
        session.sendMessage(new TextMessage("Hello, WebSocket Server!"));
    }
}

এটি doHandshake() মেথডের মাধ্যমে সার্ভারের সাথে সংযোগ স্থাপন করে এবং তারপর একটি টেক্সট মেসেজ পাঠায়।

৪. WebSocket সার্ভারের সাথে যোগাযোগ শুরু করা

এখন, আপনার WebSocket ক্লায়েন্ট WebSocketClientService ক্লাসের মাধ্যমে WebSocket সার্ভারের সাথে যোগাযোগ শুরু করতে পারে।

import org.springframework.boot.CommandLineRunner;
import org.springframework.stereotype.Component;

@Component
public class WebSocketRunner implements CommandLineRunner {

    private final WebSocketClientService webSocketClientService;

    public WebSocketRunner(WebSocketClientService webSocketClientService) {
        this.webSocketClientService = webSocketClientService;
    }

    @Override
    public void run(String... args) throws Exception {
        String serverUri = "ws://localhost:8080/socket";
        webSocketClientService.connectToWebSocketServer(serverUri);
    }
}

এই ক্লাসটি Spring Boot অ্যাপ্লিকেশন চালু হলে WebSocket সার্ভারের সাথে সংযোগ স্থাপন করবে।

৫. STOMP (Simple Text Oriented Messaging Protocol) ব্যবহার (ঐচ্ছিক)

Spring WebSocket এর সাথে STOMP প্রোটোকল ব্যবহার করে WebSocket ক্লায়েন্টের মাধ্যমে মেসেজ আদান-প্রদান আরও সহজ করা যায়। STOMP একটি উচ্চ স্তরের প্রোটোকল যা মেসেজ ব্রোকারের সাহায্যে সার্ভারের সাথে মেসেজ আদান-প্রদান সহজ করে।

STOMP WebSocket ক্লায়েন্ট তৈরি:

1. WebSocketStompClient তৈরি করা:

   import org.springframework.web.socket.client.WebSocketStompClient;
   import org.springframework.web.socket.stomp.StompSession;
   import org.springframework.messaging.simp.stomp.StompHeaders;
   import org.springframework.web.socket.WebSocketHandler;
   import org.springframework.web.socket.client.WebSocketClient;
   import org.springframework.web.socket.client.standard.StandardWebSocketClient;
   
   @Bean
   public WebSocketStompClient stompClient() {
       return new WebSocketStompClient(webSocketClient());
   }
   

2. WebSocket সার্ভারে STOMP মেসেজ পাঠানো:

   @Autowired
   private WebSocketStompClient stompClient;
   
   public void sendMessage() {
       String serverUri = "ws://localhost:8080/ws";
       StompSession session = stompClient.connect(serverUri, new MyStompSessionHandler()).get();
   
       // মেসেজ পাঠানো
       session.send("/app/hello", "Hello from STOMP Client".getBytes());
   }
   

3. STOMP Session Handler:

   import org.springframework.messaging.simp.stomp.StompSessionHandler;
   import org.springframework.messaging.simp.stomp.StompCommand;
   import org.springframework.messaging.simp.stomp.StompHeaders;
   import org.springframework.messaging.simp.stomp.StompFrame;
   
   public class MyStompSessionHandler implements StompSessionHandler {
       @Override
       public void handleFrame(StompHeaders headers, Object payload) {
           System.out.println("Received message: " + new String((byte[]) payload));
       }
   
       @Override
       public void handleException(StompHeaders headers, StompCommand command, String message, Throwable ex) {
           System.out.println("Exception: " + message);
       }
   }
   

৬. WebSocket Client-এ Error Handling ও Disconnect Logic

WebSocket ক্লায়েন্টে সাধারণত error handling এবং disconnect ম্যানেজমেন্ট করার জন্য কিছু অতিরিক্ত লজিক যুক্ত করা হয়।

@Override
public void afterConnectionClosed(WebSocketSession session, CloseStatus status) throws Exception {
    System.out.println("Connection closed: " + status);
}

@Override
public void handleTransportError(WebSocketSession session, Throwable exception) throws Exception {
    System.err.println("Error occurred: " + exception.getMessage());
}

উপসংহার

Spring Boot-এ WebSocket ক্লায়েন্ট তৈরি করার মাধ্যমে আপনি real-time অ্যাপ্লিকেশন তৈরি করতে পারেন যা দ্রুত এবং স্থিতিশীল ডেটা আদান-প্রদান সক্ষম করে। WebSocket ক্লায়েন্ট তৈরি করার জন্য Spring WebSocket এবং STOMP ব্যবহার করা সহজ এবং কার্যকর, যা আপনার মাইক্রোসার্ভিস বা চ্যাট অ্যাপ্লিকেশন এর মত রিয়েল-টাইম সিস্টেমগুলির জন্য আদর্শ।

Spring Boot Client ব্যবহার করে STOMP (Simple Text Oriented Messaging Protocol) প্রটোকল মাধ্যমে রিয়েল-টাইম কমিউনিকেশন সেটআপ করার জন্য আপনাকে কিছু নির্দিষ্ট ধাপ অনুসরণ করতে হবে। STOMP সাধারণত WebSocketের সাথে ব্যবহার করা হয়, যা একটি টেক্সট-বেসড মেসেজিং প্রোটোকল এবং রিয়েল-টাইম কমিউনিকেশন অ্যাপ্লিকেশনগুলোতে কার্যকরী।

এখানে একটি সাধারণ উদাহরণ দেওয়া হচ্ছে যা Spring Boot অ্যাপ্লিকেশনে STOMP প্রটোকল ব্যবহার করে WebSocket কনফিগার এবং ক্লায়েন্ট তৈরি করার জন্য প্রযোজ্য।

১. Spring Boot Server Side (WebSocket Configuration)

প্রথমত, Spring Boot এর WebSocket সার্ভার কনফিগার করতে হবে।

1.1 WebSocket Configuration ক্লাস তৈরি করুন

import org.springframework.context.annotation.Configuration;
import org.springframework.messaging.simp.config.MessageBrokerRegistry;
import org.springframework.web.socket.config.annotation.EnableWebSocketMessageBroker;
import org.springframework.web.socket.config.annotation.WebSocketMessageBrokerConfigurer;

@Configuration
@EnableWebSocketMessageBroker
public class WebSocketConfig implements WebSocketMessageBrokerConfigurer {

    @Override
    public void configureMessageBroker(MessageBrokerRegistry config) {
        // "/topic" prefix will be used for broadcast messages
        config.enableSimpleBroker("/topic");
        // "/app" prefix will be used for client messages
        config.setApplicationDestinationPrefixes("/app");
    }

    @Override
    public void registerStompEndpoints(StompEndpointRegistry registry) {
        // "/gs-guide-websocket" is the endpoint to connect with the WebSocket
        registry.addEndpoint("/gs-guide-websocket").withSockJS();
    }
}

1.2 Controller ক্লাস তৈরি করুন

এখন, আপনাকে একটি @MessageMapping ব্যবহার করে WebSocket এর মাধ্যমে মেসেজ হ্যান্ডল করার জন্য একটি কন্ট্রোলার তৈরি করতে হবে।

import org.springframework.messaging.handler.annotation.MessageMapping;
import org.springframework.messaging.simp.SimpMessagingTemplate;
import org.springframework.stereotype.Controller;

@Controller
public class MessageController {

    private final SimpMessagingTemplate messagingTemplate;

    public MessageController(SimpMessagingTemplate messagingTemplate) {
        this.messagingTemplate = messagingTemplate;
    }

    @MessageMapping("/hello")
    public void handleMessage(String message) {
        // Broadcasting message to all connected clients
        messagingTemplate.convertAndSend("/topic/greetings", "Hello, " + message);
    }
}

২. Spring Boot Client Side (STOMP Client)

Spring Boot ক্লায়েন্ট সাইডে STOMP প্রটোকল ব্যবহার করতে হলে, JavaScript এবং SockJS লাইব্রেরি ব্যবহার করে WebSocket কানেকশন তৈরি করতে হবে।

2.1 HTML এবং JavaScript ক্লায়েন্ট তৈরি করুন

<!DOCTYPE html>
<html>
<head>
    <title>STOMP WebSocket Example</title>
    <script src="https://cdn.jsdelivr.net/npm/sockjs-client@1.5.0/dist/sockjs.min.js"></script>
    <script src="https://cdn.jsdelivr.net/npm/stompjs@2.3.3/dist/stomp.min.js"></script>
</head>
<body>
    <div>
        <h1>Spring Boot WebSocket Client</h1>
        <input type="text" id="name" placeholder="Enter your name" />
        <button onclick="sendMessage()">Send Message</button>
        <div id="greetings"></div>
    </div>

    <script type="text/javascript">
        var stompClient = null;

        // Connect to WebSocket endpoint
        function connect() {
            var socket = new SockJS('/gs-guide-websocket'); // WebSocket connection URL
            stompClient = Stomp.over(socket);
            stompClient.connect({}, function (frame) {
                console.log('Connected: ' + frame);
                stompClient.subscribe('/topic/greetings', function (greeting) {
                    showGreeting(greeting.body);
                });
            });
        }

        // Send message to the server
        function sendMessage() {
            var name = document.getElementById("name").value;
            stompClient.send("/app/hello", {}, name);
        }

        // Display received greeting message
        function showGreeting(message) {
            var response = document.getElementById("greetings");
            response.innerHTML = message;
        }

        // Initiate the connection
        connect();
    </script>
</body>
</html>

৩. Running the Application

এখন আপনার Spring Boot অ্যাপ্লিকেশন রান করতে পারবেন এবং HTML ক্লায়েন্ট ব্যবহার করে রিয়েল-টাইম কমিউনিকেশন পরীক্ষা করতে পারবেন।

1. প্রথমে Spring Boot অ্যাপ্লিকেশন রান করুন।
2. তারপর, HTML ফাইলটি ব্রাউজারে ওপেন করুন।
3. একটি নাম লিখে "Send Message" বোতামে ক্লিক করুন, এবং ক্লায়েন্টটি রিয়েল-টাইমে সার্ভার থেকে একটি গ্রিটিং মেসেজ পাবে।

এই উদাহরণটি STOMP এবং WebSocket ব্যবহার করে Spring Boot অ্যাপ্লিকেশন এ রিয়েল-টাইম মেসেজিং কিভাবে কাজ করে, তা দেখায়।

WebSocket একটি শক্তিশালী প্রোটোকল যা ক্লায়েন্ট এবং সার্ভারের মধ্যে দুই-দিকে ডেটা স্ট্রিমিং এবং কমিউনিকেশন এর জন্য ব্যবহৃত হয়। এটি HTTP প্রোটোকলের উপর ভিত্তি করে, কিন্তু একবার কানেকশন স্থাপন হয়ে গেলে, এটি একটি persistent connection তৈরি করে যা দুইটি পক্ষের মধ্যে দুই-দিকে যোগাযোগ করতে দেয়।

Spring Boot-এ WebSocket ক্লায়েন্ট তৈরি করার জন্য, আমরা Spring WebSocket এবং Stomp protocol ব্যবহার করতে পারি, যা real-time messaging সমর্থন করে।

Step-by-Step WebSocket Client Integration in Spring Boot

Step 1: প্রয়োজনীয় ডিপেন্ডেন্সি যোগ করা

pom.xml ফাইলে WebSocket ক্লায়েন্টের জন্য প্রয়োজনীয় ডিপেন্ডেন্সি যোগ করুন:

<dependencies>
    <!-- Spring WebSocket -->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-websocket</artifactId>
    </dependency>
    
    <!-- Spring WebSocket STOMP (Simple Text Oriented Messaging Protocol) -->
    <dependency>
        <groupId>org.springframework.messaging</groupId>
        <artifactId>spring-messaging</artifactId>
    </dependency>

    <!-- Spring Boot Starter Web -->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
    </dependency>
</dependencies>

Step 2: WebSocket Configuration (Server Side)

Spring Boot WebSocket সার্ভার কনফিগারেশন তৈরি করুন:

import org.springframework.context.annotation.Configuration;
import org.springframework.web.socket.WebSocketHandler;
import org.springframework.web.socket.config.annotation.EnableWebSocket;
import org.springframework.web.socket.config.annotation.WebSocketHandlerRegistry;
import org.springframework.web.socket.config.annotation.WebSocketConfigurer;
import org.springframework.web.socket.handler.TextWebSocketHandler;

@Configuration
@EnableWebSocket
public class WebSocketConfig implements WebSocketConfigurer {

    @Override
    public void registerWebSocketHandlers(WebSocketHandlerRegistry registry) {
        registry.addHandler(new WebSocketHandler(), "/ws").setAllowedOrigins("*");
    }

    private static class WebSocketHandler extends TextWebSocketHandler {
        @Override
        public void handleTextMessage(org.springframework.web.socket.WebSocketSession session, org.springframework.web.socket.TextMessage message) throws Exception {
            // Handling WebSocket message
            session.sendMessage(new org.springframework.web.socket.TextMessage("Hello, " + message.getPayload()));
        }
    }
}

এখানে, আমরা /ws এ WebSocket কানেকশন খুলেছি, এবং TextWebSocketHandler ব্যবহার করে একটি সিম্পল মেসেজ হ্যান্ডলিং ফাংশন তৈরি করেছি।

Step 3: WebSocket Client Configuration

WebSocket ক্লায়েন্ট কনফিগারেশন তৈরি করার জন্য, আমরা StompSession এবং WebSocketStompClient ব্যবহার করব। Stomp (Simple Text Oriented Messaging Protocol) হলো একটি প্রোটোকল যা WebSocket এর উপর টেক্সট মেসেজ আদান-প্রদান সমর্থন করে।

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.messaging.simp.stomp.StompSessionHandlerAdapter;
import org.springframework.messaging.simp.stomp.StompSession;
import org.springframework.messaging.simp.stomp.StompHeaders;
import org.springframework.messaging.simp.stomp.StompClient;
import org.springframework.web.socket.client.WebSocketClient;
import org.springframework.web.socket.client.WebSocketStompClient;
import org.springframework.web.socket.WebSocketStompClient;
import org.springframework.web.socket.client.WebSocketHttpHeaders;
import org.springframework.web.socket.client.StandardWebSocketClient;

@Configuration
public class WebSocketClientConfig {

    @Bean
    public WebSocketStompClient stompClient() {
        WebSocketClient webSocketClient = new StandardWebSocketClient();
        return new WebSocketStompClient(webSocketClient);
    }
}

Step 4: WebSocket Client Integration

এখন, একটি WebSocket ক্লায়েন্ট তৈরি করব, যা স্টাম্প সার্ভারে সংযোগ করবে এবং মেসেজ পাঠাবে এবং গ্রহণ করবে।

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.messaging.simp.stomp.StompSession;
import org.springframework.messaging.simp.stomp.StompSessionHandler;
import org.springframework.messaging.simp.stomp.StompFrameHandler;
import org.springframework.messaging.simp.stomp.StompHeaders;
import org.springframework.web.socket.client.WebSocketStompClient;
import org.springframework.stereotype.Service;
import org.springframework.messaging.simp.stomp.StompSession;

@Service
public class WebSocketClientService {

    @Autowired
    private WebSocketStompClient stompClient;

    public void connectToWebSocket() {
        String url = "ws://localhost:8080/ws";
        stompClient.connect(url, new StompSessionHandlerAdapter() {
            @Override
            public void afterConnected(StompSession session, StompHeaders connectedHeaders) {
                System.out.println("WebSocket connected");
                session.send("/app/hello", "Hello, WebSocket!");
                session.subscribe("/topic/greetings", new StompFrameHandler() {
                    @Override
                    public Type getPayloadType(StompHeaders headers) {
                        return String.class;
                    }

                    @Override
                    public void handleFrame(StompHeaders headers, Object payload) {
                        System.out.println("Received message: " + payload);
                    }
                });
            }
        });
    }
}

এখানে, StompSessionHandler ব্যবহার করা হয়েছে WebSocket সার্ভারের সাথে সংযোগ স্থাপন করার জন্য এবং মেসেজ পাঠানোর জন্য। আমরা একটি বার্তা পাঠাচ্ছি /app/hello এবং এর পর থেকে /topic/greetings এ সিস্টেম থেকে মেসেজ গ্রহণ করছি।

Step 5: Client Request থেকে WebSocket কল করা

Spring Boot অ্যাপ্লিকেশন চলাকালে WebSocket ক্লায়েন্ট কল করার জন্য:

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.CommandLineRunner;
import org.springframework.stereotype.Component;

@Component
public class AppRunner implements CommandLineRunner {

    @Autowired
    private WebSocketClientService webSocketClientService;

    @Override
    public void run(String... args) throws Exception {
        webSocketClientService.connectToWebSocket();
    }
}

এখন, যখন Spring Boot অ্যাপ্লিকেশন চালু হবে, এটি WebSocket সার্ভারে সংযোগ করবে এবং মেসেজ পাঠাবে এবং গ্রহণ করবে।

Step 6: Testing

আপনার WebSocket সার্ভার এবং ক্লায়েন্ট দুইটি চালু করে পরীক্ষা করুন:

1. WebSocket Server: WebSocket সার্ভারটি /ws URL এ ক্লায়েন্টের কানেকশন গ্রহণ করবে এবং বার্তা পাঠাবে।
2. WebSocket Client: ক্লায়েন্টটি /ws এ সংযোগ করবে এবং বার্তা পাঠাবে। সার্ভার থেকে রেসপন্স পেলে তা কনসোলে প্রিন্ট হবে।

উপসংহার

Spring Boot ক্লায়েন্টে WebSocket ইন্টিগ্রেশন করার জন্য আমরা WebSocketStompClient ব্যবহার করেছি, যা STOMP প্রোটোকল ব্যবহার করে real-time messaging সমর্থন করে। WebSocket ক্লায়েন্ট তৈরি করা অনেক সহজ এবং এটি bi-directional communication এর সুবিধা দেয়। এই সেটআপটি বিশেষ করে chat applications, live data updates, অথবা gaming apps-এ ব্যবহৃত হয়, যেখানে real-time communication অত্যন্ত গুরুত্বপূর্ণ।